home *** CD-ROM | disk | FTP | other *** search
/ Windows Game Programming for Dummies (2nd Edition) / WinGamProgFD.iso / mac / DirectX SDK / DXSDK / include / tune.h < prev    next >
C/C++ Source or Header  |  2001-10-08  |  32KB  |  816 lines
  1. //------------------------------------------------------------------------------
  2. // File: Tune.h
  3. //
  4. // Desc: Additional infrastructure to extend the tuner.idl.  Works nicely
  5. //       from C++.
  6. //
  7. // Copyright (c) 1999 - 2001, Microsoft Corporation.  All rights reserved.
  8. //------------------------------------------------------------------------------
  9.  
  10.  
  11. #pragma once
  12.  
  13. #ifndef TUNE_H
  14. #define TUNE_H
  15.  
  16. #include <tuner.h>
  17.  
  18. namespace BDATuningModel {
  19.  
  20. const long DEFAULT_MIN_CHANNEL = 2;
  21. const long DEFAULT_MAX_CHANNEL = 999;
  22. const long DEFAULT_MIN_FREQUENCY = 535;  //bottom us am
  23. const long DEFAULT_MAX_FREQUENCY = 108000; // top us fm
  24. const long DEFAULT_ANALOG_TUNER_COUNTRY_CODE = 1; //usa
  25. const TunerInputType DEFAULT_ANALOG_TUNER_INPUT_TYPE = TunerInputCable; //usa
  26.  
  27. typedef CComQIPtr<ITuningSpaceContainer> PQTuningSpaceContainer;
  28. typedef CComQIPtr<ITuningSpace> PQTuningSpace;
  29. typedef CComQIPtr<IAnalogRadioTuningSpace> PQAnalogRadioTuningSpace;
  30. typedef CComQIPtr<IAnalogTVTuningSpace> PQAnalogTVTuningSpace;
  31. typedef CComQIPtr<IATSCTuningSpace> PQATSCTuningSpace;
  32. typedef CComQIPtr<ITuneRequest> PQTuneRequest;
  33. typedef CComQIPtr<IChannelTuneRequest> PQChannelTuneRequest;
  34. typedef CComQIPtr<IATSCChannelTuneRequest> PQATSCChannelTuneRequest;
  35. typedef CComQIPtr<ILocator> PQLocator;
  36. typedef CComQIPtr<IATSCLocator> PQATSCLocator;
  37. typedef CComQIPtr<IDVBTuningSpace> PQDVBTuningSpace;
  38. typedef CComQIPtr<IDVBTuneRequest> PQDVBTuneRequest;
  39. typedef CComQIPtr<IDVBSLocator> PQDVBSLocator;
  40. typedef CComQIPtr<IDVBTLocator> PQDVBTLocator;
  41.  
  42. // tuning space container
  43. class TNTuningSpaceContainer : public PQTuningSpaceContainer {
  44.      TNTuningSpaceContainer() {}
  45.      TNTuningSpaceContainer(const PQTuningSpaceContainer &a) : PQTuningSpaceContainer(a) {}
  46.      TNTuningSpaceContainer(ITuningSpace *p) : PQTuningSpaceContainer(p) {}
  47.      TNTuningSpaceContainer(IUnknown *p) : PQTuningSpaceContainer(p) {}
  48.      TNTuningSpaceContainer(const TNTuningSpaceContainer &a) : PQTuningSpaceContainer(a) {}
  49.      TNTuningSpaceContainer& operator=(TNTuningSpaceContainer& rhs) {
  50.         PQTuningSpaceContainer::operator=(rhs);
  51.         return *this;
  52.     }
  53.  
  54. };
  55.  
  56. // tuning spaces
  57. template<class TUNINGSPACETYPE, class TUNEREQUESTTYPE> class TNTuningSpaceHelper : public TUNINGSPACETYPE {
  58. public:
  59.     TNTuningSpaceHelper() {}
  60.     TNTuningSpaceHelper(const TUNINGSPACETYPE &a) : TUNINGSPACETYPE(a) {}
  61.     TNTuningSpaceHelper(ITuningSpace *p) : TUNINGSPACETYPE(p) {}
  62.     TNTuningSpaceHelper(IUnknown *p) : TUNINGSPACETYPE(p) {}
  63.     TNTuningSpaceHelper(const TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE> &a) : TUNINGSPACETYPE(a) {}
  64.     TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& rhs) {
  65.         TUNINGSPACETYPE::operator=(rhs);
  66.         return *this;
  67.     }
  68.     TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TUNINGSPACETYPE& rhs) {
  69.         TUNINGSPACETYPE::operator=(rhs);
  70.         return *this;
  71.     }
  72.     TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(IUnknown *rhs) {
  73.         TUNINGSPACETYPE::operator=(rhs);
  74.         return *this;
  75.     }
  76.     TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(ITuningSpace *rhs) {
  77.         TUNINGSPACETYPE::operator=(rhs);
  78.         return *this;
  79.     }
  80.     bool  operator==(TUNINGSPACETYPE& rhs) {
  81.         CComBSTR rhsname;
  82.         HRESULT hr = rhs->get_UniqueName(&rhsname);
  83.         if (FAILED(hr)) {
  84.             return false;
  85.         }
  86.         CComBSTR name;
  87.         hr = (*this)->get_UniqueName(&name);
  88.         if (FAILED(hr)) {
  89.             return false;
  90.         }
  91.         return name == rhsname;
  92.     }
  93.     bool  operator!=(TUNINGSPACETYPE& rhs) {
  94.         return !operator==(rhs);
  95.     }
  96.     PQTuneRequest CreateTuneRequest() {
  97.         PQTuneRequest p;
  98.         HRESULT hr = (*this)->CreateTuneRequest(&p);
  99.         if (FAILED(hr)) {
  100.             return PQTuneRequest();
  101.         }
  102.         return p;
  103.     }
  104.  
  105.     PQLocator Locator() {
  106.         _ASSERT(*this);
  107.         PQLocator ts;
  108.         HRESULT hr = (*this)->get_DefaultLocator(&ts);
  109.         if (FAILED(hr)) {
  110.             return PQLocator();
  111.         }
  112.         return ts;
  113.     }
  114.  
  115.     HRESULT Locator(PQLocator& l) {
  116.         _ASSERT(*this);
  117.         return (*this)->put_Locator(l);
  118.     }
  119.  
  120.     void Clone() {
  121.         PQTuningSpace t;
  122.         HRESULT hr = (*this)->Clone(&t);
  123.         if (FAILED(hr) || !t) {
  124.             Release();  // clone failed, clear ourselves
  125.             return;
  126.         }
  127.         TUNINGSPACETYPE::operator=(t);
  128.     }
  129.  
  130. };
  131.  
  132. typedef TNTuningSpaceHelper<PQTuningSpace, PQTuneRequest> TNTuningSpace;
  133.  
  134. template<class TUNINGSPACETYPE, class TUNEREQUESTTYPE> class TNAnalogRadioTuningSpaceHelper : public TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE> {
  135. public:
  136.      TNAnalogRadioTuningSpaceHelper() {}
  137.      TNAnalogRadioTuningSpaceHelper(const TUNINGSPACETYPE &a) : TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(a) {}
  138.      TNAnalogRadioTuningSpaceHelper(IUnknown *p) : TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(p) {}
  139.      TNAnalogRadioTuningSpaceHelper(const TNAnalogRadioTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE> &a) : TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(a) {}
  140.      TNAnalogRadioTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TNAnalogRadioTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& rhs) {
  141.         TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(rhs);
  142.         return *this;
  143.      }
  144.      template<class TS, class TR> TNAnalogRadioTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TNTuningSpaceHelper<TS, TR>& rhs) {
  145.         TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(TUNINGSPACETYPE(rhs));
  146.         return *this;
  147.      }
  148.      TNAnalogRadioTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TUNINGSPACETYPE& rhs) {
  149.         TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(rhs);
  150.         return *this;
  151.     }
  152.      TNAnalogRadioTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(IUnknown* rhs) {
  153.         TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(rhs);
  154.         return *this;
  155.     }
  156.     long MaxFrequency() {
  157.         _ASSERT(*this);
  158.         long freq;
  159.         HRESULT hr = (*this)->get_MaxFrequency(&freq);
  160.         if (FAILED(hr)) {
  161.             freq = DEFAULT_MAX_FREQUENCY;
  162.         }
  163.         return freq;
  164.     }
  165.     HRESULT MaxFrequency(long freq) {
  166.         _ASSERT(*this);
  167.         return (*this)->put_MaxFrequency(freq);
  168.     }
  169.     long MinFrequency() {
  170.         _ASSERT(*this);
  171.         long freq;
  172.         HRESULT hr = (*this)->get_MinFrequency(&freq);
  173.         if (FAILED(hr)) {
  174.             freq = DEFAULT_MIN_FREQUENCY;
  175.         }
  176.         return freq;
  177.     }
  178.     HRESULT MinFrequency(long freq) {
  179.         _ASSERT(*this);
  180.         return (*this)->put_MinFrequency(freq);
  181.     }
  182. };
  183. typedef TNAnalogRadioTuningSpaceHelper<PQAnalogRadioTuningSpace, PQChannelTuneRequest> TNAnalogRadioTuningSpace;
  184.  
  185. template<class TUNINGSPACETYPE, class TUNEREQUESTTYPE> class TNAnalogTVTuningSpaceHelper : public TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE> {
  186. public:
  187.     TNAnalogTVTuningSpaceHelper() {}
  188.     TNAnalogTVTuningSpaceHelper(const TUNINGSPACETYPE &a) : TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(a) {}
  189.     TNAnalogTVTuningSpaceHelper(IUnknown *p) : TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(p) {}
  190.     TNAnalogTVTuningSpaceHelper(const TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE> &a) : TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(a) {}
  191.     TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& rhs) {
  192.         TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(rhs);
  193.         return *this;
  194.     }
  195.     template<class TS, class TR> TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TNTuningSpaceHelper<TS, TR>& rhs) {
  196.         TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(TUNINGSPACETYPE(rhs));
  197.         return *this;
  198.     }
  199.     TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TUNINGSPACETYPE& rhs) {
  200.         TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(rhs);
  201.         return *this;
  202.     }
  203.     TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(IUnknown* rhs) {
  204.         TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(rhs);
  205.         return *this;
  206.     }
  207.     TunerInputType InputType() {
  208.         _ASSERT(*this);
  209.         TunerInputType ti;
  210.         HRESULT hr = (*this)->get_InputType(&ti);
  211.         if (FAILED(hr)) {
  212.             ti = DEFAULT_ANALOG_TUNER_INPUT_TYPE;
  213.         }
  214.         return ti;
  215.     }
  216.     HRESULT InputType(TunerInputType ti) {
  217.         _ASSERT(*this);
  218.         return (*this)->put_InputType(&ti);
  219.     }
  220.     long CountryCode() {
  221.         _ASSERT(*this);
  222.         long cc;
  223.         HRESULT hr = (*this)->get_CountryCode(&cc);
  224.         if (FAILED(hr)) {
  225.             cc = DEFAULT_ANALOG_TUNER_INPUT_TYPE;
  226.         }
  227.         return cc;
  228.     }
  229.     HRESULT CountryCode(long cc) {
  230.         _ASSERT(*this);
  231.         return (*this)->put_CountryCode(cc);
  232.     }
  233.     long MinChannel() {
  234.         _ASSERT(*this);
  235.         long chan;
  236.         HRESULT hr = (*this)->get_MinChannel(&chan);
  237.         if (FAILED(hr)) {
  238.             chan = DEFAULT_MIN_CHANNEL;
  239.         }
  240.         return chan;
  241.     }
  242.     HRESULT MinChannel(long chan) {
  243.         _ASSERT(*this);
  244.         return (*this)->put_MinChannel(chan);
  245.     }
  246.     long MaxChannel() {
  247.         _ASSERT(*this);
  248.         long chan;
  249.         HRESULT hr = (*this)->get_MaxChannel(&chan);
  250.         if (FAILED(hr)) {
  251.             chan = DEFAULT_MAX_CHANNEL;
  252.         }
  253.         return chan;
  254.     }
  255.     HRESULT MaxChannel(long chan) {
  256.         _ASSERT(*this);
  257.         return (*this)->put_MaxChannel(chan);
  258.     }
  259. };
  260. typedef TNAnalogTVTuningSpaceHelper<PQAnalogTVTuningSpace, PQChannelTuneRequest> TNAnalogTVTuningSpace;
  261.  
  262. template<class TUNINGSPACETYPE, class TUNEREQUESTTYPE> class TNATSCTuningSpaceHelper : public TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE> {
  263. public:
  264.     TNATSCTuningSpaceHelper() {}
  265.     TNATSCTuningSpaceHelper(const TUNINGSPACETYPE &a) : TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(a) {}
  266.     TNATSCTuningSpaceHelper(IUnknown *p) : TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(p) {}
  267.     TNATSCTuningSpaceHelper(const TNATSCTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE> &a) : TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(a) {}
  268.  
  269.     TNATSCTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TNATSCTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& rhs) {
  270.         TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(rhs);
  271.         return *this;
  272.     }
  273.     template<class TS, class TR> TNATSCTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TNTuningSpaceHelper<TS, TR>& rhs) {
  274.         TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(TUNINGSPACETYPE(rhs));
  275.         return *this;
  276.     }
  277.     TNATSCTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TUNINGSPACETYPE& rhs) {
  278.         TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(rhs);
  279.         return *this;
  280.     }
  281.     TNATSCTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(IUnknown* rhs) {
  282.         TNAnalogTVTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(rhs);
  283.         return *this;
  284.     }
  285.     long MinMinorChannel() {
  286.         _ASSERT(*this);
  287.         long chan;
  288.         HRESULT hr = (*this)->get_MinMinorChannel(&chan);
  289.         if (FAILED(hr)) {
  290.             chan = DEFAULT_MIN_CHANNEL;
  291.         }
  292.         return chan;
  293.     }
  294.     HRESULT MinMinorChannel(long chan) {
  295.         _ASSERT(*this);
  296.         return (*this)->put_MinMinorChannel(chan);
  297.     }
  298.  
  299.     long MaxMinorChannel() {
  300.         _ASSERT(*this);
  301.         long chan;
  302.         HRESULT hr = (*this)->get_MaxMinorChannel(&chan);
  303.         if (FAILED(hr)) {
  304.             chan = DEFAULT_MAX_CHANNEL;
  305.         }
  306.         return chan;
  307.     }
  308.     HRESULT MaxMinorChannel(long chan) {
  309.         _ASSERT(*this);
  310.         return (*this)->put_MaxMinorChannel(chan);
  311.     }
  312.     long MinPhysicalChannel() {
  313.         _ASSERT(*this);
  314.         long chan;
  315.         HRESULT hr = (*this)->get_MinPhysicalChannel(&chan);
  316.         if (FAILED(hr)) {
  317.             chan = DEFAULT_MIN_CHANNEL;
  318.         }
  319.         return chan;
  320.     }
  321.     HRESULT MinPhysicalChannel(long chan) {
  322.         _ASSERT(*this);
  323.         return (*this)->put_MinPhysicalChannel(chan);
  324.     }
  325.  
  326.     long MaxPhysicalChannel() {
  327.         _ASSERT(*this);
  328.         long chan;
  329.         HRESULT hr = (*this)->get_MaxPhysicalChannel(&chan);
  330.         if (FAILED(hr)) {
  331.             chan = DEFAULT_MAX_CHANNEL;
  332.         }
  333.         return chan;
  334.     }
  335.  
  336.     HRESULT MaxPhysicalChannel(long chan) {
  337.         _ASSERT(*this);
  338.         return (*this)->put_MaxPhysicalChannel(chan);
  339.     }
  340. };
  341. typedef TNATSCTuningSpaceHelper<PQATSCTuningSpace, PQATSCChannelTuneRequest> TNATSCTuningSpace;
  342.  
  343. // dvb tuning space
  344. template<class TUNINGSPACETYPE, class TUNEREQUESTTYPE> class TNDVBTuningSpaceHelper : public TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE> {
  345. public:
  346.      TNDVBTuningSpaceHelper() {}
  347.      TNDVBTuningSpaceHelper(const TUNINGSPACETYPE &a) : TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(a) {}
  348.      TNDVBTuningSpaceHelper(IUnknown *p) : TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(p) {}
  349.      TNDVBTuningSpaceHelper(const TNDVBTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE> &a) : TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>(a) {}
  350.      TNDVBTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TNDVBTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& rhs) {
  351.         TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(rhs);
  352.         return *this;
  353.      }
  354.      template<class TS, class TR> TNDVBTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TNTuningSpaceHelper<TS, TR>& rhs) {
  355.         TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(TUNINGSPACETYPE(rhs));
  356.         return *this;
  357.      }
  358.      TNDVBTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(TUNINGSPACETYPE& rhs) {
  359.         TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(rhs);
  360.         return *this;
  361.     }
  362.      TNDVBTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>& operator=(IUnknown* rhs) {
  363.         TNTuningSpaceHelper<TUNINGSPACETYPE, TUNEREQUESTTYPE>::operator=(rhs);
  364.         return *this;
  365.     }
  366.     DVBSystemType SystemType() const {
  367.         DVBSystemType st;
  368.         HRESULT hr = (*this)->get_SystemType(&st);
  369.         if (FAILED(hr)) {
  370.             return DVB_Cable;
  371.         }
  372.         return st;
  373.     }
  374.     HRESULT SystemType(DVBSystemType st) {
  375.         _ASSERT(*this);
  376.         return (*this)->put_SystemType(st);
  377.     }
  378. };
  379. typedef TNDVBTuningSpaceHelper<PQDVBTuningSpace, PQDVBTuneRequest> TNDVBTuningSpace;
  380.  
  381. // locators
  382. template<class LOCATORTYPE> class TNLocatorHelper : public LOCATORTYPE {
  383. public:
  384.      TNLocatorHelper() {}
  385.      TNLocatorHelper(const LOCATORTYPE &a) : LOCATORTYPE(a) {}
  386.      TNLocatorHelper(IUnknown *p) : LOCATORTYPE(p) {}
  387.      TNLocatorHelper(const TNLocatorHelper<LOCATORTYPE> &a) : LOCATORTYPE(a) {}
  388.      TNLocatorHelper(ILocator *p) : LOCATORTYPE(p) {}
  389.      TNLocatorHelper<LOCATORTYPE>& operator=(TNLocatorHelper<LOCATORTYPE>& rhs) {
  390.         LOCATORTYPE::operator=(rhs);
  391.         return *this;
  392.     }
  393.      TNLocatorHelper<LOCATORTYPE>& operator=(LOCATORTYPE& rhs) {
  394.         LOCATORTYPE::operator=(rhs);
  395.         return *this;
  396.     }
  397.      TNLocatorHelper<LOCATORTYPE>& operator=(ILocator* rhs) {
  398.         LOCATORTYPE::operator=(rhs);
  399.         return *this;
  400.     }
  401.      TNLocatorHelper<LOCATORTYPE>& operator=(IUnknown* rhs) {
  402.         LOCATORTYPE::operator=(rhs);
  403.         return *this;
  404.     }
  405.  
  406.     void Clone() {
  407.         PQLocator t;
  408.         HRESULT hr = (*this)->Clone(&t);
  409.         if (FAILED(hr) || !t) {
  410.             Release();  // clone failed, clear ourselves
  411.             return;
  412.         }
  413.         LOCATORTYPE::operator=(t);
  414.     }
  415.  
  416.     long CarrierFrequency() {
  417.         _ASSERT(*this);
  418.         long f;
  419.         HRESULT hr = (*this)->get_CarrierFrequency(&f);
  420.         if (FAILED(hr)) {
  421.             return -1;
  422.         }
  423.         return f;
  424.     }
  425.     HRESULT CarrierFrequency(long f) {
  426.         _ASSERT(*this);
  427.         return (*this)->put_CarrierFrequency(f);
  428.     }
  429.  
  430.     FECMethod InnerFEC() {
  431.         _ASSERT(*this);
  432.         FECMethod f;
  433.         HRESULT hr = (*this)->get_InnerFEC(&f);
  434.         if (FAILED(hr)) {
  435.             return BDA_FEC_METHOD_NOT_SET;
  436.         }
  437.         return f;
  438.     }
  439.     HRESULT InnerFEC(FECMethod f) {
  440.         _ASSERT(*this);
  441.         return (*this)->put_InnerFEC(f);
  442.     }
  443.     BinaryConvolutionCodeRate InnerFECRate() {
  444.         _ASSERT(*this);
  445.         BinaryConvolutionCodeRate f;
  446.         HRESULT hr = (*this)->get_InnerFECRate(&f);
  447.         if (FAILED(hr)) {
  448.             return BDA_BCC_RATE_NOT_SET;
  449.         }
  450.         return f;
  451.     }
  452.     HRESULT InnerFECRate(BinaryConvolutionCodeRate f) {
  453.         _ASSERT(*this);
  454.         return (*this)->put_InnerFECRate(f);
  455.     }
  456.     FECMethod OuterFEC() {
  457.         _ASSERT(*this);
  458.         FECMethod f;
  459.         HRESULT hr = (*this)->get_OuterFEC(&f);
  460.         if (FAILED(hr)) {
  461.             return BDA_FEC_METHOD_NOT_SET;
  462.         }
  463.         return f;
  464.     }
  465.     HRESULT OuterFEC(FECMethod f) {
  466.         _ASSERT(*this);
  467.         return (*this)->put_OuterFEC(f);
  468.     }
  469.     BinaryConvolutionCodeRate OuterFECRate() {
  470.         _ASSERT(*this);
  471.         BinaryConvolutionCodeRate f;
  472.         HRESULT hr = (*this)->get_OuterFECRate(&f);
  473.         if (FAILED(hr)) {
  474.             return BDA_BCC_RATE_NOT_SET;
  475.         }
  476.         return f;
  477.     }
  478.     HRESULT OuterFECRate(BinaryConvolutionCodeRate f) {
  479.         _ASSERT(*this);
  480.         return (*this)->put_OuterFECRate(f);
  481.     }
  482.     ModulationType Modulation() {
  483.         _ASSERT(*this);
  484.         ModulationType f;
  485.         HRESULT hr = (*this)->get_Modulation(&f);
  486.         if (FAILED(hr)) {
  487.             return BDA_MOD_NOT_SET;
  488.         }
  489.         return f;
  490.     }
  491.     HRESULT Modulation(ModulationType f) {
  492.         _ASSERT(*this);
  493.         return (*this)->put_Modulation(f);
  494.     }
  495.  
  496.     long SymbolRate() {
  497.         _ASSERT(*this);
  498.         long f;
  499.         HRESULT hr = (*this)->get_SymbolRate(&f);
  500.         if (FAILED(hr)) {
  501.             return -1;
  502.         }
  503.         return f;
  504.     }
  505.     HRESULT SymbolRate(long f) {
  506.         _ASSERT(*this);
  507.         return (*this)->put_SymbolRate(f);
  508.     }
  509.  
  510. };
  511. typedef TNLocatorHelper<PQLocator> TNLocator;
  512.  
  513. template<class LOCATORTYPE> class TNATSCLocatorHelper : public TNLocatorHelper<LOCATORTYPE> {
  514. public:
  515.     TNATSCLocatorHelper() {}
  516.     TNATSCLocatorHelper(const LOCATORTYPE &a) : TNLocatorHelper<LOCATORTYPE>(a) {}
  517.     TNATSCLocatorHelper(IUnknown *p) : TNLocatorHelper<LOCATORTYPE>(p) {}
  518.     TNATSCLocatorHelper(const TNATSCLocatorHelper<LOCATORTYPE> &a) : TNLocatorHelper<LOCATORTYPE>(a) {}
  519.     TNATSCLocatorHelper(IATSCLocator *p) : TNLocatorHelper<LOCATORTYPE>(p) {}
  520.     TNATSCLocatorHelper(const TNLocatorHelper<LOCATORTYPE> &a) : TNLocatorHelper<LOCATORTYPE>(a) {}
  521.     TNATSCLocatorHelper<LOCATORTYPE>& operator=(TNATSCLocatorHelper<LOCATORTYPE>& rhs) {
  522.         TNLocatorHelper<LOCATORTYPE>::operator=(rhs);
  523.         return *this;
  524.     }
  525.     TNATSCLocatorHelper<LOCATORTYPE>& operator=(TNLocatorHelper<LOCATORTYPE>& rhs) {
  526.         TNLocatorHelper<LOCATORTYPE>::operator=(rhs);
  527.         return *this;
  528.     }
  529.     TNATSCLocatorHelper<LOCATORTYPE>& operator=(LOCATORTYPE& rhs) {
  530.         TNLocatorHelper<LOCATORTYPE>::operator=(rhs);
  531.         return *this;
  532.     }
  533.     TNATSCLocatorHelper<LOCATORTYPE>& operator=(IATSCLocator* rhs) {
  534.         TNLocatorHelper<LOCATORTYPE>::operator=(rhs);
  535.         return *this;
  536.     }
  537.     TNATSCLocatorHelper<LOCATORTYPE>& operator=(IUnknown* rhs) {
  538.         TNLocatorHelper<LOCATORTYPE>::operator=(rhs);
  539.         return *this;
  540.     }
  541.  
  542.     long PhysicalChannel() {
  543.         _ASSERT(*this);
  544.         long pc;
  545.         HRESULT hr = (*this)->get_PhysicalChannel(&pc);
  546.         if (FAILED(hr)) {
  547.             return -1;
  548.         }
  549.         return pc;
  550.     }
  551.     HRESULT PhysicalChannel(long pc) {
  552.         _ASSERT(*this);
  553.         return (*this)->put_PhysicalChannel(pc);
  554.     }
  555.  
  556.     long TSID() {
  557.         _ASSERT(*this);
  558.         long pc;
  559.         HRESULT hr = (*this)->get_TSID(&pc);
  560.         if (FAILED(hr)) {
  561.             return -1;
  562.         }
  563.         return pc;
  564.     }
  565.     HRESULT TSID(long pc) {
  566.         _ASSERT(*this);
  567.         return (*this)->put_TSID(pc);
  568.     }
  569.  
  570.     long ProgramNumber() {
  571.         _ASSERT(*this);
  572.         long pc;
  573.         HRESULT hr = (*this)->get_ProgramNumber(&pc);
  574.         if (FAILED(hr)) {
  575.             return -1;
  576.         }
  577.         return pc;
  578.     }
  579.     HRESULT ProgramNumber(long pc) {
  580.         _ASSERT(*this);
  581.         return (*this)->put_ProgramNumber(pc);
  582.     }
  583. };
  584. typedef TNATSCLocatorHelper<PQATSCLocator> TNATSCLocator;
  585.  
  586. // tune requests
  587. template<class TUNEREQUESTTYPE, class LOCATORTYPE> class TNTuneRequestHelper : public TUNEREQUESTTYPE {
  588. public:
  589.      TNTuneRequestHelper() {}
  590.      TNTuneRequestHelper(const TUNEREQUESTTYPE &a) : TUNEREQUESTTYPE(a) {}
  591.      TNTuneRequestHelper(IUnknown *p) : TUNEREQUESTTYPE(p) {}
  592.      TNTuneRequestHelper(const TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE> &a) : TUNEREQUESTTYPE(a) {}
  593.      TNTuneRequestHelper(ITuneRequest *p) : TUNEREQUESTTYPE(p) {}
  594.      TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& rhs) {
  595.         TUNEREQUESTTYPE::operator=(rhs);
  596.         return *this;
  597.     }
  598.      TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(TUNEREQUESTTYPE& rhs) {
  599.         TUNEREQUESTTYPE::operator=(rhs);
  600.         return *this;
  601.     }
  602.      TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(ITuneRequest* rhs) {
  603.         TUNEREQUESTTYPE::operator=(rhs);
  604.         return *this;
  605.     }
  606.      TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(IUnknown* rhs) {
  607.         TUNEREQUESTTYPE::operator=(rhs);
  608.         return *this;
  609.     }
  610.     // this function creates a new instance of the base ITuneRequest* and copies
  611.     // all the values of the current ITuneRequest and sets this to the new one
  612.     // this provides the value semantics needed by the network providers
  613.     void Clone() {
  614.         PQTuneRequest t;
  615.         HRESULT hr = (*this)->Clone(&t);
  616.         if (FAILED(hr) || !t) {
  617.             Release();  // clone failed, clear ourselves
  618.             return;
  619.         }
  620.         TUNEREQUESTTYPE::operator=(t);
  621.     }
  622.  
  623.     PQTuningSpace TuningSpace() {
  624.         _ASSERT(*this);
  625.         PQTuningSpace ts;
  626.         HRESULT hr = (*this)->get_TuningSpace(&ts);
  627.         if (FAILED(hr)) {
  628.             return PQTuningSpace();
  629.         }
  630.         return ts;
  631.     }
  632.  
  633.     LOCATORTYPE Locator() {
  634.         _ASSERT(*this);
  635.         PQLocator pc;
  636.         HRESULT hr = (*this)->get_Locator(&pc);
  637.         if (FAILED(hr)) {
  638.             return PQLocator().p;
  639.         }
  640.         return pc.p;
  641.     }
  642.     HRESULT Locator(LOCATORTYPE& pc) {
  643.         _ASSERT(*this);
  644.         return (*this)->put_Locator(pc);
  645.     }
  646. };
  647.  
  648. typedef TNTuneRequestHelper<PQTuneRequest, PQLocator> TNTuneRequest;
  649.  
  650. template<class TUNEREQUESTTYPE, class LOCATORTYPE> class TNChannelTuneRequestHelper : public TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE> {
  651. public:
  652.      TNChannelTuneRequestHelper() {}
  653.      TNChannelTuneRequestHelper(const TNTuneRequest &a) : TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(a) {}
  654.      TNChannelTuneRequestHelper(IChannelTuneRequest *p) : TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(p) {}
  655.      TNChannelTuneRequestHelper(IUnknown *p) : TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(p) {}
  656.      TNChannelTuneRequestHelper(const TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE> &a) : TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(a) {}
  657.      TNChannelTuneRequestHelper(const TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE> &a) : TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(a) {}
  658.      TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& rhs) {
  659.         TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>::operator=(rhs);
  660.         return *this;
  661.     }
  662.     template<class TR, class LOC> TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(TNTuneRequestHelper<TR, LOC>& rhs) {
  663.         TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>::operator=(TUNEREQUESTTYPE(rhs));
  664.         return *this;
  665.     }
  666.      TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(TUNEREQUESTTYPE& rhs) {
  667.         TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>::operator=(rhs);
  668.         return *this;
  669.     }
  670.      TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(IChannelTuneRequest* rhs) {
  671.         TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>::operator=(rhs);
  672.         return *this;
  673.     }
  674.      TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(IUnknown* rhs) {
  675.         TUNEREQUESTTYPE::operator=(rhs);
  676.         return *this;
  677.     }
  678.     long Channel() {
  679.         _ASSERT(*this);
  680.         long c;
  681.         HRESULT hr = (*this)->get_Channel(&c);
  682.         if (FAILED(hr)) {
  683.             return -1;
  684.         }
  685.         return c;
  686.     }
  687.     HRESULT Channel(long c) {
  688.         _ASSERT(*this);
  689.         return (*this)->put_Channel(c);
  690.     }
  691. };
  692.  
  693. typedef TNChannelTuneRequestHelper<PQChannelTuneRequest, PQLocator> TNChannelTuneRequest;
  694.  
  695. template<class TUNEREQUESTTYPE, class LOCATORTYPE> class TNATSCChannelTuneRequestHelper : public TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE> {
  696. public:
  697.     TNATSCChannelTuneRequestHelper() {}
  698.     TNATSCChannelTuneRequestHelper(const TNTuneRequest &a) : TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(a) {}
  699.     TNATSCChannelTuneRequestHelper(IATSCChannelTuneRequest *p) : TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(p) {}
  700.     TNATSCChannelTuneRequestHelper(IUnknown *p) : TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(p) {}
  701.     TNATSCChannelTuneRequestHelper(const TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE> &a) : TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(a) {}
  702.     TNATSCChannelTuneRequestHelper(const TNATSCChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE> &a) : TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(a) {}
  703.     TNATSCChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(TNATSCChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& rhs) {
  704.         TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>::operator=(rhs);
  705.         return *this;
  706.     }
  707.     template<class TR, class LOC>TNATSCChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(TNTuneRequestHelper<TR, LOC>& rhs) {
  708.         TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>::operator=(TR(rhs));
  709.         return *this;
  710.     }
  711.     TNATSCChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(TUNEREQUESTTYPE& rhs) {
  712.         TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>::operator=(rhs);
  713.         return *this;
  714.     }
  715.     TNATSCChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(IATSCChannelTuneRequest *rhs) {
  716.         TNChannelTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>::operator=(rhs);
  717.         return *this;
  718.     }
  719.     TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(IUnknown* rhs) {
  720.         TUNEREQUESTTYPE::operator=(rhs);
  721.         return *this;
  722.     }
  723.     long MinorChannel() {
  724.         _ASSERT(*this);
  725.         long mc;
  726.         HRESULT hr = (*this)->get_MinorChannel(&mc);
  727.         if (FAILED(hr)) {
  728.             return -1;
  729.         }
  730.         return mc;
  731.     }
  732.     HRESULT MinorChannel(long mc) {
  733.         _ASSERT(*this);
  734.         return (*this)->put_MinorChannel(mc);
  735.     }
  736. };
  737. typedef TNATSCChannelTuneRequestHelper<PQATSCChannelTuneRequest, PQATSCLocator> TNATSCChannelTuneRequest;
  738.  
  739. template<class TUNEREQUESTTYPE, class LOCATORTYPE> class TNDVBTuneRequestHelper : public TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE> {
  740. public:
  741.      TNDVBTuneRequestHelper() {}
  742.      TNDVBTuneRequestHelper(const TNTuneRequest &a) : TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(a) {}
  743.      TNDVBTuneRequestHelper(IDVBTuneRequest *p) : TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(p) {}
  744.      TNDVBTuneRequestHelper(IUnknown *p) : TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(p) {}
  745.      TNDVBTuneRequestHelper(const TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE> &a) : TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(a) {}
  746.      TNDVBTuneRequestHelper(const TNDVBTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE> &a) : TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>(a) {}
  747.      TNDVBTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(TNDVBTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& rhs) {
  748.         TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>::operator=(rhs);
  749.         return *this;
  750.     }
  751.     template<class TR, class LOC> TNDVBTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(TNTuneRequestHelper<TR, LOC>& rhs) {
  752.         TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>::operator=(TUNEREQUESTTYPE(rhs));
  753.         return *this;
  754.     }
  755.      TNDVBTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(TUNEREQUESTTYPE& rhs) {
  756.         TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>::operator=(rhs);
  757.         return *this;
  758.     }
  759.      TNDVBTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(IDVBTuneRequest* rhs) {
  760.         TNTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>::operator=(rhs);
  761.         return *this;
  762.     }
  763.      TNDVBTuneRequestHelper<TUNEREQUESTTYPE, LOCATORTYPE>& operator=(IUnknown* rhs) {
  764.         TUNEREQUESTTYPE::operator=(rhs);
  765.         return *this;
  766.     }
  767.     long ONID() {
  768.         _ASSERT(*this);
  769.         long c;
  770.         HRESULT hr = (*this)->get_ONID(&c);
  771.         if (FAILED(hr)) {
  772.             return -1;
  773.         }
  774.         return c;
  775.     }
  776.     HRESULT ONID(long c) {
  777.         _ASSERT(*this);
  778.         return (*this)->put_ONID(c);
  779.     }
  780.     long TSID() {
  781.         _ASSERT(*this);
  782.         long c;
  783.         HRESULT hr = (*this)->get_TSID(&c);
  784.         if (FAILED(hr)) {
  785.             return -1;
  786.         }
  787.         return c;
  788.     }
  789.     HRESULT TSID(long c) {
  790.         _ASSERT(*this);
  791.         return (*this)->put_TSID(c);
  792.     }
  793.     long SID() {
  794.         _ASSERT(*this);
  795.         long c;
  796.         HRESULT hr = (*this)->get_SID(&c);
  797.         if (FAILED(hr)) {
  798.             return -1;
  799.         }
  800.         return c;
  801.     }
  802.     HRESULT SID(long c) {
  803.         _ASSERT(*this);
  804.         return (*this)->put_SID(c);
  805.     }
  806. };
  807. typedef TNDVBTuneRequestHelper<PQDVBTuneRequest, PQLocator> TNDVBTuneRequest;
  808. }; // namespace
  809.  
  810. #ifndef NO_DEFAULT_BDATUNINGMODEL_NAMESPACE
  811. using namespace BDATuningModel;
  812. #endif
  813.  
  814. #endif
  815. // end of file - tune.h
  816.